"""
翻页处理器模块

负责检测和处理网页分页，自动获取下一页URL
"""

import time
import logging
import urllib.parse
from urllib.parse import urlparse
from bs4 import BeautifulSoup

logger = logging.getLogger('paginator')

class BasePaginator:
    """翻页处理器基类"""
    
    def __init__(self):
        """初始化翻页处理器"""
        self.domains = []  # 支持的域名列表
    
    def can_paginate(self, url):
        """
        检查是否可以处理该URL的翻页
        
        参数:
            url: 要检查的URL
        
        返回:
            布尔值，表示是否可以处理
        """
        if not self.domains:  # 如果没有指定域名，则支持所有域名
            return True
        
        domain = urlparse(url).netloc
        return any(domain.endswith(d) for d in self.domains)
    
    def get_next_page(self, html, url):
        """
        获取下一页URL
        
        参数:
            html: HTML内容
            url: 当前页面URL
        
        返回:
            下一页URL或None
        """
        raise NotImplementedError("子类必须实现get_next_page方法")


class ConfigPaginator(BasePaginator):
    """基于配置的翻页处理器"""
    
    def __init__(self, config):
        """
        初始化翻页处理器
        
        参数:
            config: 配置对象
        """
        super().__init__()
        self.config = config
        
        # 从配置中读取设置
        self.enabled = config.getboolean('PAGINATION', 'enabled', fallback=True)
        self.next_page_selector = config.get('PAGINATION', 'next_page_selector', fallback='a.next-page')
        self.max_pages = config.getint('PAGINATION', 'max_pages', fallback=500)
        self.page_delay = config.getfloat('PAGINATION', 'page_delay', fallback=1)
        
        # 当前页码计数器
        self.current_page = 1
        
        logger.info(f"翻页处理器初始化完成，启用状态: {self.enabled}")
    
    def get_next_page(self, html, url):
        """
        获取下一页URL
        
        参数:
            html: HTML内容
            url: 当前页面URL
        
        返回:
            下一页URL或None
        """
        if not self.enabled:
            logger.debug("翻页处理器已禁用")
            return None
        
        # 检查是否达到最大页数
        if self.current_page >= self.max_pages:
            logger.info(f"已达到最大页数 {self.max_pages}")
            return None
        
        try:
            soup = BeautifulSoup(html, 'html.parser')
            
            # 尝试多个选择器，用逗号分隔
            selectors = [s.strip() for s in self.next_page_selector.split(',')]
            
            for selector in selectors:
                # 查找下一页链接
                next_links = soup.select(selector)
                
                if next_links:
                    for link in next_links:
                        # 如果找到链接，构建绝对URL
                        if 'href' in link.attrs:
                            href = link['href']
                            next_url = urllib.parse.urljoin(url, href)
                            
                            # 增加页码计数
                            self.current_page += 1
                            
                            logger.info(f"找到下一页: {next_url} (第 {self.current_page} 页)")
                            
                            # 翻页延迟
                            if self.page_delay > 0:
                                logger.debug(f"翻页延迟 {self.page_delay} 秒")
                                time.sleep(self.page_delay)
                            
                            return next_url
            
            logger.info(f"未找到下一页 (当前第 {self.current_page} 页)")
            return None
            
        except Exception as e:
            logger.error(f"获取下一页时出错: {e}")
            return None
    
    def reset(self):
        """重置页码计数器"""
        self.current_page = 1


class PaginatorManager:
    """翻页处理器管理器"""
    
    def __init__(self, config):
        """
        初始化翻页处理器管理器
        
        参数:
            config: 配置对象
        """
        self.config = config
        self.paginators = {}  # 域名 -> 翻页处理器映射
        
        # 添加基于配置的翻页处理器
        self.config_paginator = ConfigPaginator(config)
        
        # 加载自定义翻页处理器插件
        self._load_plugins()
        
        logger.info("翻页处理器管理器初始化完成")
    
    def _load_plugins(self):
        """加载自定义翻页处理器插件"""
        # TODO: 实现插件加载逻辑
        pass
    
    def get_paginator(self, url):
        """
        为URL获取合适的翻页处理器
        
        参数:
            url: 要处理翻页的URL
        
        返回:
            翻页处理器对象或None
        """
        domain = urlparse(url).netloc
        
        # 如果已经有该域名的处理器，直接返回
        if domain in self.paginators:
            return self.paginators[domain]
        
        # 先检查自定义处理器
        for paginator in self.paginators.values():
            if paginator is not self.config_paginator and paginator.can_paginate(url):
                logger.info(f"使用自定义翻页处理器: {paginator.__class__.__name__} 处理 {url}")
                self.paginators[domain] = paginator
                return paginator
        
        # 然后使用基于配置的处理器
        if self.config_paginator.enabled:
            logger.info(f"使用配置翻页处理器处理 {url}")
            # 为每个域名创建新的处理器实例，避免页码计数混淆
            new_paginator = ConfigPaginator(self.config)
            self.paginators[domain] = new_paginator
            return new_paginator
        
        logger.warning(f"未找到合适的翻页处理器: {url}")
        return None
    
    def get_next_page(self, html, url):
        """
        获取下一页URL
        
        参数:
            html: HTML内容
            url: 当前页面URL
        
        返回:
            下一页URL或None
        """
        paginator = self.get_paginator(url)
        if paginator:
            return paginator.get_next_page(html, url)
        return None
